home *** CD-ROM | disk | FTP | other *** search
/ SGI Hot Mix 17 / Hot Mix 17.iso / HM17_SGI / research / external / rpc / rpc_clnt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-08  |  34.1 KB  |  1,187 lines
  1. /* idl_rpc_client.c - Client side routines for the IDL RPC feature */
  2.  
  3. /*
  4.   Copyright (c) 1988-1997, Research Systems Inc.  All rights reserved.
  5.   This software includes information which is proprietary to and a
  6.   trade secret of Research Systems, Inc.  It is not to be disclosed
  7.   to anyone outside of this organization. Reproduction by any means
  8.   whatsoever is  prohibited without express written permission.
  9.  */
  10.  
  11. static char rcsid[] = "$Id: rpc_clnt.c,v 1.5 1997/01/29 21:17:45 kirk Exp $";
  12.  
  13.  
  14. /*
  15.  *  Contents:
  16.  *  This file contains routines that are used on the client side
  17.  *  of the IDL RPC routines. This includes all API functions as 
  18.  *  well as API support routines.
  19.  */
  20.  
  21.  
  22. /*
  23.  * Header files
  24.  */
  25.  
  26. #include "idl_rpc.h"
  27. #include "rpc_xdr.h"
  28.  
  29. #include <sys/time.h>
  30. #include <sys/socket.h>
  31. #include <netdb.h>
  32.  
  33. /*
  34.  * Declare the global timeout variable and set a default value
  35.  */
  36. static struct timeval   s_rpcTimeOut  = { 60, 0 }; /* default of 60 secs */
  37.  
  38. /*
  39.  * local functions 
  40.  */
  41. void idl_rpc_delvar(IDL_VPTR pVar);         /* deletes dynamic memory */
  42. void idl_rpc_strup(char * dst, char * src); /* upcases an char string */
  43. int idl_rpc_valid_str(char *s);                /* syntax check a command line */
  44. /*
  45.  * Declare the rpc buffer size
  46.  */
  47. #define      RPC_BUF_SIZE      (8*1024)
  48.  
  49. /*********************************************************************
  50.  * IDL_RPCInit()
  51.  *
  52.  * Purpose:
  53.  *    This function is used to perform the connection to the rpc server
  54.  *    and other startup initialization of the rpc client. All idl rpc
  55.  *    clients should call this routine before executing any IDL rpc
  56.  *    operations.
  57.  *
  58.  * entry:
  59.  *    lServerId      - integer ID of the rpc server. 0 => use default
  60.  *    pszHostname    - the hostname of the server. NULL => localhost
  61.  *
  62.  * exit:
  63.  *    Function returns a CLIENT pointer that references the client/server
  64.  *    connection or returns NULL if there was an error.
  65.  */
  66. CLIENT *IDL_RPCInit( long lServerId, char* pszHostname)
  67. {
  68.    int                   iSock = RPC_ANYSOCK;
  69.    struct hostent       *pHostent;
  70.    struct sockaddr_in    ServerAddr;
  71.    CLIENT               *pClient;
  72. /*
  73.  * Check input parameters
  74.  */
  75.    if(lServerId == 0)
  76.       lServerId = IDL_RPC_DEFAULT_ID;
  77.    
  78.    if( (pszHostname == (char*)NULL) || (*pszHostname == '\0'))
  79.        pszHostname = "localhost";
  80. /*
  81.  * Get the host information
  82.  */
  83.    if( (pHostent = gethostbyname(pszHostname)) == (struct hostent*)NULL){
  84.        perror("gethostbyname");
  85.        return (CLIENT*)NULL;
  86.      }
  87. /*
  88.  * Copy the host address into the server address struct
  89.  */
  90.    bcopy(pHostent->h_addr, (caddr_t)&ServerAddr.sin_addr, pHostent->h_length);
  91.    ServerAddr.sin_family      = AF_INET; /* address type */
  92.    ServerAddr.sin_port        = 0;
  93. /*
  94.  * Connect to the client usign TCP/IP
  95.  */
  96.    if( (pClient = (CLIENT*)clnttcp_create(&ServerAddr, lServerId, 
  97.              IDL_RPC_DEFAULT_VERSION, &iSock,
  98.              RPC_BUF_SIZE, RPC_BUF_SIZE)) == (CLIENT*)NULL){
  99.        clnt_pcreateerror("clnttcp_create");
  100.    }
  101.    return pClient;        /* return the client struct */
  102. }
  103. /******************************************************************
  104.  * IDL_RPCCleanup()
  105.  *
  106.  * Purpose:
  107.  *    This routine should be called when the user no longer desires to 
  108.  *    use the rpc server. This routine will unregister the client and
  109.  *    if desired by the user, halt the rpc server.      
  110.  *
  111.  * entry:
  112.  *    pClient    - The CLIENT ^ that refs the server/client connection
  113.  *             that will be affected.
  114.  *    iKill      - If true the RPC server will be killed.
  115.  *
  116.  * exit:
  117.  *    RPC client unregistered and if iKill was set, the server is killed.
  118.  *
  119.  */
  120. int IDL_RPCCleanup( CLIENT *pClient, int iKill)
  121. {
  122.    enum clnt_stat    rpcResult=RPC_SUCCESS;
  123. /*
  124.  * Does the user want to kill the server?
  125.  */
  126.    if(iKill)
  127.       rpcResult = clnt_call(pClient, IDL_RPC_CLEANUP, /* kill server */
  128.                 (xdrproc_t)xdr_void, 0, (xdrproc_t)xdr_void, 0, 
  129.                 s_rpcTimeOut);
  130.    if(pClient != (CLIENT*)NULL)
  131.       clnt_destroy(pClient);
  132.  
  133.    return (rpcResult == RPC_SUCCESS ? 1 : 0); 
  134. }
  135. /******************************************************************
  136.  * IDL_RPCTimeout()
  137.  *
  138.  * Purpose:
  139.  *    This routine is used to set the value of the rpc timeout being
  140.  *    used in the rpc calls to the server. The timeout value units 
  141.  *    are seconds. Returns 0 on failure.
  142.  *
  143.  * entry:
  144.  *    lTimeOut     - New timeout value in seconds.
  145.  *
  146.  * exit:
  147.  *    Returns 1 on success, 0 on failure. 
  148.  *    
  149.  */
  150. int IDL_RPCTimeout(long lTimeOut)
  151. {
  152. /*
  153.  * make sure that the timeout value looks "sane".
  154.  */
  155.    if(lTimeOut <= 0)
  156.       return 0;
  157.    s_rpcTimeOut.tv_sec = lTimeOut;
  158.    return 1;
  159. }
  160. /***************************************************************************
  161.  * idl_rpc_valid_str()
  162.  *
  163.  * Purpose:
  164.  *    This function checks to make sure that a string contains
  165.  *    a valid IDL command. Commands the start with $ or contain
  166.  *    "$" that are used for line continuations can cause the IDL 
  167.  *     server to hang. This function is used to validate command
  168.  *    lines before they are sent to the server.
  169.  *
  170.  * entry:
  171.  *     s    - command string to check.
  172.  *
  173.  * exit:
  174.  *    0 - command string is ok
  175.  *     -1 - command string is invalid
  176.  */
  177. int idl_rpc_valid_str(char *s)
  178. {
  179.    if(s == (char*)NULL) 
  180.       return 0;            /* valid */
  181.   
  182.    if(*s == '$')
  183.       return -1;            /* invalid */
  184. /*
  185.  * Loop thru and check for a '$'
  186.  */
  187.    while(*++s){
  188.      if( *s == '$'){
  189.      /*
  190.       * if this is preceeded by a alpha or an '_' it should be a
  191.       * variable name, otherwise signal an error.
  192.       */
  193.        if( !isalpha(*(s-1)) &&  *(s-1) != '_' && *(s-1) != '$')
  194.           return -1;
  195.      }
  196.    }  
  197.    return 0;    /* command string is OK */
  198. }
  199. /**********************************************************************
  200.  * IDL_RPCExecuteStr()
  201.  *
  202.  * Purpose:
  203.  *     This routine is used to send an IDL command string to the rpc
  204.  *     server. This string should be in the form of a single IDL command line.
  205.  *     The return value of this function is the value of !ERROR after 
  206.  *     the completion of the command.
  207.  *
  208.  * entry:
  209.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  210.  *    pszCommand    - The command line to send to the server
  211.  *
  212.  * exit:
  213.  *    Return Value:
  214.  *        0     - Command executed ok.
  215.  *        -1    - Invalid command line.
  216.  *        other    - Value of !ERROR in the IDL server.
  217.  *
  218.  */
  219. int IDL_RPCExecuteStr( CLIENT *pClient, char * pszCommand)
  220. { 
  221.   enum clnt_stat     rpcResult;
  222.   int                iCmdResult;
  223. /* 
  224.  * check for a null command...why send it.
  225.  */
  226.    if(pszCommand == (char*)NULL)
  227.       return 1;            /* null commands are ok */
  228. /* 
  229.  * A command spawn using $ can cause problems and should not be sent
  230.  * to the server. Lets check for this.
  231.  */
  232.    if(idl_rpc_valid_str(pszCommand)){
  233.       fprintf(stderr, "IDL_RPCExecuteStr: %s\n",
  234.           "Shell command and line continue symbols not allowed");
  235.       return 0;
  236.     }
  237. /* 
  238.  * Send the command string to the server.
  239.  */
  240.    rpcResult = clnt_call(pClient, IDL_RPC_EXE_STR, 
  241.              (xdrproc_t)xdr_wrapstring, (char*)&pszCommand, 
  242.              (xdrproc_t)xdr_int, (char*)&iCmdResult,
  243.              s_rpcTimeOut);
  244.    if(rpcResult != RPC_SUCCESS){
  245.       clnt_perror( pClient, "IDL_RPCExecuteStr");
  246.       iCmdResult = 0;
  247.    }
  248.  
  249.    return iCmdResult;
  250. }
  251. /*****************************************************************
  252.  * IDL_RPCOutputCapture()
  253.  *
  254.  * Purpose:
  255.  *     This routine is used to enable and disable the capture of the 
  256.  *     output lines from IDL on the server side. If the input argument 
  257.  *     is greater than zero, the capture of output lines is enabled with
  258.  *     the size of the output queue (in lines) equal to the input parameter.
  259.  *     If the input parameter is <= zero, the caputure queue is emptied and
  260.  *     the capture of output lines is disabled.
  261.  *
  262.  * entry:
  263.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  264.  *    n_lines        - The number of output lines to store. A value <=0 
  265.  *              disables the storage of output lines.
  266.  * exit:
  267.  *    Return Values:
  268.  *        1 - All is ok
  269.  *        0 - an error occurred.
  270.  */
  271. int IDL_RPCOutputCapture( CLIENT *pClient, int n_lines)
  272. {
  273.    enum clnt_stat     rpcResult;
  274.    int                iResult;
  275. /*
  276.  * Send the number of lines to capture to the server.
  277.  */
  278.    rpcResult = clnt_call(pClient, IDL_RPC_OUT_CAPTURE, 
  279.              (xdrproc_t)xdr_int, (char*)&n_lines, 
  280.              (xdrproc_t)xdr_int, (char*)&iResult,
  281.              s_rpcTimeOut);
  282.  
  283.    if(rpcResult != RPC_SUCCESS){
  284.       clnt_perror(pClient, "IDL_RPCOutputCapture");
  285.       return 0;
  286.    }
  287.    return 1; /* thats it */
  288. }
  289. /*******************************************************************
  290.  * IDL_RPCSetMainVariable()
  291.  *
  292.  * Purpose:
  293.  *    This function is used to set the value of a variable that 
  294.  *    is at the main level of the IDL RPC server. If the variable
  295.  *    doesnt exist at the main level on the server side, the server
  296.  *    will create it.
  297.  *
  298.  * entry:
  299.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  300.  *    Name        - The name of the variable to be set.
  301.  *    pVar        - An IDL_VPTR that contains the value that the variable
  302.  *              should be set to.
  303.  * exit:
  304.  *   Return Values:
  305.  *        0 - ok
  306.  *        1 - Error occurred
  307.  */
  308. int IDL_RPCSetMainVariable( CLIENT *pClient, char *Name, IDL_VPTR pVar)
  309. {
  310.    enum clnt_stat   rpcResult;
  311.    IDL_RPC_VARIABLE rpcVar;    /* struct that holds vptr and Name */
  312.    int              iResult=0;
  313.    char             szBuffer[124];
  314. /*
  315.  * Put the information in the rpc variable structure and send it
  316.  * to the server.
  317.  */
  318.    idl_rpc_strup(szBuffer, Name);    /* upcase name */
  319.    rpcVar.name = szBuffer;
  320.    rpcVar.pVariable = pVar;
  321. /*
  322.  * If the variable is a string that is dynamically allocated, make
  323.  * sure that the V_DYNAMIC flag is set. With out this flag set,
  324.  * there can be problems on the server side.
  325.  */
  326.    if(pVar->type == IDL_TYP_STRING){
  327.       if(pVar->value.str.stype){
  328.          pVar->flags |= IDL_V_DYNAMIC;
  329.       }
  330.    }
  331. /*
  332.  * Send this info to the server.
  333.  */
  334.    rpcResult = clnt_call(pClient, IDL_RPC_SET_MAIN_VAR,
  335.              (xdrproc_t)IDL_RPC_xdr_variable, (char*)&rpcVar,
  336.              (xdrproc_t)xdr_void, 0, s_rpcTimeOut);
  337.  
  338.    if(rpcResult != RPC_SUCCESS){
  339.       clnt_perror(pClient, "IDL_RPCSetMainVariable");
  340.       return 0;
  341.    }
  342.    return 1;
  343. }
  344. /*************************************************************
  345.  * IDL_RPCGetMainVariable()
  346.  *
  347.  * Purpose:
  348.  *     This function is used to get the value of a variable 
  349.  *    that is located at the main IDL level on the IDL RPC server.
  350.  *    The IDL_VPTR that is returned from this function is dynamically
  351.  *    allocated and should be deallocated using the IDL_RPCDeltmp() 
  352.  *    function when the user is finished with it.
  353.  * 
  354.  * entry: 
  355.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  356.  *    Name        - The name of the desired variable.
  357.  *
  358.  * exit:
  359.  *     Return Value:
  360.  *        On success this function returns an IDL_VPTR that points
  361.  *        to an IDL_VARIABLE structure that contains the value of 
  362.  *        the requested variable. On failure this function returns
  363.  *        NULL.
  364.  */
  365. IDL_VPTR IDL_RPCGetMainVariable(CLIENT *pClient, char *Name)
  366. {
  367.    IDL_VPTR pVar;
  368.    IDL_RPC_VARIABLE rpcVar;
  369.    enum clnt_stat   rpcResult;
  370.    char             szBuffer[124];
  371.    char           *pChar;
  372.    idl_rpc_strup(szBuffer, Name);    /* make sure it is uppercase */
  373.    bzero((char*)&rpcVar, sizeof(IDL_RPC_VARIABLE)); /* clear out  */
  374.    pChar = (char*)szBuffer;
  375. /* 
  376.  * Request the variable from the server
  377.  */
  378.    rpcResult = clnt_call(pClient, IDL_RPC_GET_MAIN_VAR,
  379.              (xdrproc_t)xdr_wrapstring, (char*)&pChar,
  380.              (xdrproc_t)IDL_RPC_xdr_variable, (char*)&rpcVar,
  381.              s_rpcTimeOut);
  382.    if(rpcResult != RPC_SUCCESS){
  383.       clnt_perror(pClient, "IDL_RPCGetMainVariable");
  384.       return (IDL_VPTR)NULL;
  385.    }
  386.    return rpcVar.pVariable;    /* return the value */
  387. }
  388. /*******************************************************************
  389.  * IDL_RPCSetVariable()
  390.  *
  391.  * Purpose:
  392.  *    This function is used to set the value of a variable that 
  393.  *    is in the current scope of the IDL RPC server. If the variable
  394.  *    doesnt exist at this level on the server side, the server
  395.  *    will create it.
  396.  *
  397.  * entry:
  398.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  399.  *    Name        - The name of the variable to be set.
  400.  *    pVar        - An IDL_VPTR that contains the value that the variable
  401.  *              should be set to.
  402.  * exit:
  403.  *   Return Values:
  404.  *        0 - ok
  405.  *        1 - Error occurred
  406.  */
  407. int IDL_RPCSetVariable( CLIENT *pClient, char *Name, IDL_VPTR pVar)
  408. {
  409.    enum clnt_stat   rpcResult;
  410.    IDL_RPC_VARIABLE rpcVar;
  411.    int              iResult=0;
  412.    char             szBuffer[124];
  413. /*
  414.  * Put the information in the rpc variable structure and send it
  415.  * to the server.
  416.  */
  417.    idl_rpc_strup(szBuffer, Name);
  418.    rpcVar.name = Name;
  419.    rpcVar.pVariable = pVar;
  420.  
  421. /*
  422.  * If the variable is a string that is dynamically allocated, make
  423.  * sure that the V_DYNAMIC flag is set. With out this flag set,
  424.  * there can be problems on the server side.
  425.  */
  426.    if(pVar->type == IDL_TYP_STRING){
  427.       if(pVar->value.str.stype){
  428.          pVar->flags |= IDL_V_DYNAMIC;
  429.       }
  430.    }
  431. /*
  432.  * Send this info to the server.
  433.  */
  434.    rpcResult = clnt_call(pClient, IDL_RPC_SET_VAR,
  435.              (xdrproc_t)IDL_RPC_xdr_variable, (char*)&rpcVar,
  436.              (xdrproc_t)xdr_void, 0, s_rpcTimeOut);
  437.  
  438.    if(rpcResult != RPC_SUCCESS){
  439.       clnt_perror(pClient, "IDL_RPCSetVariable");
  440.       iResult=0;
  441.    }
  442.    return 1;
  443. }
  444. /*************************************************************
  445.  * IDL_RPCGetVariable()
  446.  *
  447.  * Purpose:
  448.  *     This function is used to get the value of a variable 
  449.  *    that is located in the current IDL scope on the IDL RPC server.
  450.  *    The IDL_VPTR that is returned from this function is dynamically
  451.  *    allocated and should be deallocated using the IDL_RPCDeltmp() 
  452.  *    function when the user is finished with it.
  453.  * 
  454.  * entry: 
  455.  *     pClient        - The CLIENT ^ that refs the client/server connection.
  456.  *    Name        - The name of the desired variable.
  457.  *
  458.  * exit:
  459.  *     Return Value:
  460.  *        On success this function returns an IDL_VPTR that points
  461.  *        to an IDL_VARIABLE structure that contains the value of 
  462.  *        the requested variable. On failure this function returns
  463.  *        NULL.
  464.  */
  465. IDL_VPTR IDL_RPCGetVariable(CLIENT *pClient, char *Name)
  466. {
  467.    IDL_VPTR pVar;
  468.    IDL_RPC_VARIABLE rpcVar;
  469.    enum clnt_stat   rpcResult;
  470.    char             szBuffer[124];
  471.    char            *pChar;
  472.    idl_rpc_strup(szBuffer, Name);    /* make sure it is uppercase */
  473.    pChar = (char*)szBuffer;
  474.    bzero((char*)&rpcVar, sizeof(IDL_RPC_VARIABLE)); /* clear out  */
  475.    rpcResult = clnt_call(pClient, IDL_RPC_GET_VAR,
  476.              (xdrproc_t)xdr_wrapstring, (char*)&pChar,
  477.              (xdrproc_t)IDL_RPC_xdr_variable, (char*)&rpcVar,
  478.              s_rpcTimeOut);
  479.    if(rpcResult != RPC_SUCCESS){
  480.       clnt_perror(pClient, "IDL_RPCGetVariable");
  481.       return (IDL_VPTR)NULL;
  482.    }
  483.    return rpcVar.pVariable;
  484. }   
  485. /*************************************************************
  486.  * IDL_RPCOuputGetStr()
  487.  *
  488.  * Purpose:
  489.  *     This function is used to get a line from the output queue that
  490.  *     is being kept on the RPC server. The routine IDL_RPCOutputCapture()
  491.  *     MUST have been called with a positive arguement before this routine.
  492.  *
  493.  * entry:
  494.  *    pClient        - The CLIENT ^ that refs the client/server connection.
  495.  *    pLine        - A ^ to a valid structure of type pLine. This 
  496.  *              structure will be filled with the next line
  497.  *              and information about this line.
  498.  *    first        - If not 0, the value should be popped from the 
  499.  *              output queue, not dequeued.
  500.  */
  501. int IDL_RPCOutputGetStr(CLIENT *pClient, IDL_RPC_LINE_S *pLine, int first)
  502. {
  503.    enum clnt_stat     rpcResult;
  504. /*
  505.  * Get the line from the server
  506.  */
  507.    rpcResult = clnt_call(pClient, IDL_RPC_OUT_STR, 
  508.              (xdrproc_t)xdr_int, (char*)&first, 
  509.              (xdrproc_t)IDL_RPC_xdr_line_s, (char*)pLine,
  510.              s_rpcTimeOut);
  511.    if(rpcResult != RPC_SUCCESS){
  512.       clnt_perror(pClient, "IDL_RPCOutputGetStr");
  513.       return 0;
  514.    }
  515. /*
  516.  * A flag value of -1 indicates that there are no more values
  517.  * in the ouput queue
  518.  */
  519.    return (pLine->flags == -1 ? 0 : 1);
  520. }
  521. /*************************************************************
  522.  * IDL_RPCVarCopy()
  523.  * 
  524.  * Purpose:
  525.  *     Used to emulate IDL_VarCopy() on the client side. The value
  526.  *     of the source variable is copied to the destination variable.
  527.  *    If the source variable has the IDL_V_TMP flag set, any dynamic
  528.  *    part of the source variable is moved to the destination variable
  529.  *    and not copied.
  530.  *    
  531.  *    Any dynamic memory associated with the destination variable
  532.  *    is freed before the copy is performed.
  533.  *
  534.  * entry:
  535.  *    src - ^ to variable to be copied.
  536.  *    dst - ^ to variable that will have info copied to it.
  537.  *
  538.  * exit:
  539.  *    src - not changed
  540.  *    dst - Any original dynamic data has been deallocated and it now
  541.  *          contains the value that was in src.
  542.  *
  543.  */
  544. void IDL_RPCVarCopy(IDL_VPTR src, IDL_VPTR dst)
  545. {
  546.    int flags;
  547.  
  548.    flags = dst->flags;        /* save the destination flags */
  549. /*
  550.  * Free up any dynamic memory used by the dst variable 
  551.  */
  552.    idl_rpc_delvar(dst);  
  553.    dst->flags = flags & ~(IDL_V_ARR & IDL_V_DYNAMIC); /* save some flags */
  554.    dst->type = src->type;    /* get the type of the copied var */
  555. /*
  556.  * Is the variable an array?
  557.  */
  558.    if( src->flags & IDL_V_ARR){
  559.    /*
  560.     * Is the source variable a *temporary* variable (or at least
  561.     * marked as such)? If so, just copy the arr pointer to the 
  562.     * src variable.
  563.     */
  564.       if(src->flags & IDL_V_TEMP){
  565.      dst->value.arr = src->value.arr;
  566.      src->flags &=  ~(IDL_V_NOT_SCALAR); /* take out array bit */
  567.      idl_rpc_delvar(src);    /* free any other memory being used */
  568.       }else{            /* need to copy over the data! */
  569.          dst->value.arr = (IDL_ARRAY*)malloc((unsigned)sizeof(IDL_ARRAY));
  570.      if(!dst->value.arr){
  571.         perror("malloc");
  572.         return;
  573.      }
  574.       /*
  575.        * Copy over the array info.
  576.        */
  577.      bcopy((char*)src->value.arr,(char*)dst->value.arr, sizeof(IDL_ARRAY));
  578.      dst->value.arr->data = (UCHAR*)malloc(src->value.arr->arr_len);
  579.      if(!dst->value.arr->data){
  580.         perror("malloc");
  581.         free((char*)dst->value.arr);
  582.         return;
  583.      }
  584.       /*
  585.        * Copy over the array info
  586.        */
  587.      bcopy((char*)src->value.arr->data, (char*)dst->value.arr->data, 
  588.            src->value.arr->arr_len);
  589.      dst->flags |= IDL_V_DYNAMIC;
  590.       }
  591.       dst->flags |= IDL_V_ARR;
  592.    }else {            /* a scalar */
  593.    /*
  594.     * just copy over the alltypes union
  595.     */
  596.       bcopy((char*)&dst->value, (char*)&src->value, sizeof(IDL_ALLTYPES));
  597.       dst->flags = dst->flags & ~(IDL_V_NOT_SCALAR);
  598.    }
  599. }
  600. /********************************************************************
  601.  * IDL_RPCDeltmp()
  602.  *
  603.  * Purpose:
  604.  *     This function emulates the IDL_Deltmp() function. This is used
  605.  *     to delete any dynamic memory that is allocated to create
  606.  *     a variable. This function calls idl_rpc_delvar() which keys off
  607.  *    the IDL_V_DYNAMIC flag or if a scalar is a string. 
  608.  *
  609.  *    If the IDL_V_TEMP bit is set, the IDL_VARIABLE will also be 
  610.  *    deallocated.
  611.  *
  612.  * entry:
  613.  *    vTmp  - A variable that will have its memory freed.
  614.  *
  615.  * exit:
  616.  *    vTmp - Any dynamic memory associated with vTmp is freed.
  617.  */
  618. void IDL_RPCDeltmp( IDL_VPTR vTmp)
  619. {
  620.    if(!vTmp)
  621.       return;   
  622. /*
  623.  * Free up any dynamic memory in the variable
  624.  */
  625.    idl_rpc_delvar(vTmp);
  626. /*
  627.  * If the IDL_V_TEMP bit is not set, return. 
  628.  */
  629.    if(!(vTmp->flags & IDL_V_TEMP))
  630.       return;
  631.    free((char*)vTmp);  /* free the IDL_VARIABLE */
  632. }
  633. /*********************************************************************
  634.  * IDL_RPCGettmp()
  635.  *
  636.  * Purpose:
  637.  *     Used to emulate the IDL function IDL_Gettmp(). Allocates
  638.  *     memory for an IDL_VARIABLE struct and returns a pointer 
  639.  *     to this value. The IDL_V_TEMP flag is set to indicate
  640.  *     that this value will need to be free'd later in the program.
  641.  *
  642.  * entry:
  643.  *    Nothing.
  644.  *
  645.  * exit:
  646.  *     Return Value:
  647.  *         Returns an IDL_VPTR that points to an IDL_VARIABLE 
  648.  *        struct with the IDL_V_TEMP bit set in the flags field.
  649.  *        On an error a NULL is returned.
  650.  */
  651. IDL_VPTR IDL_RPCGettmp(void)
  652. {
  653.    IDL_VPTR vTmp;
  654.  
  655.    vTmp = (IDL_VPTR)malloc((unsigned)sizeof(IDL_VARIABLE));
  656.    if(!vTmp){
  657.      perror("malloc");
  658.      return (IDL_VPTR)NULL;
  659.    }
  660.    bzero((char*)vTmp, sizeof(IDL_VARIABLE));
  661.    vTmp->flags = IDL_V_TEMP;  /* used to mark the IDL_VARIABLE as dynamic */
  662.    return vTmp;
  663. }
  664. /*********************************************************************
  665.  * IDL_RPCStoreScalar()
  666.  *
  667.  * Purpose:
  668.  *    This function is used to store a scalar value into an 
  669.  *    IDL_VPTR variable. This function emulates the Callable IDL
  670.  *    function IDL_StoreScalar.
  671.  *
  672.  * entry:
  673.  *     dest     - The ^ to the IDL_VARIABLE struct where the scalar
  674.  *          value is stored. Any dynamic memory that is contained
  675.  *          in dest will be deallocated before the store takes place.
  676.  *    type    - The type of the value to be stored.
  677.  *    value    - A ^ to an IDL_ALLTYPES union that contains the 
  678.  *          scalar value to store in the destination variable.
  679.  *
  680.  * exit:
  681.  *     The scalar value is stored in the destination variable.
  682.  */
  683. void IDL_RPCStoreScalar(IDL_VPTR dest, int type, 
  684.             IDL_ALLTYPES *value)
  685. {
  686.    int i;
  687.    IDL_STRING *pStr;
  688. /*
  689.  * Free up any dynamic memory being used by the variable
  690.  */
  691.    if(dest->flags & IDL_V_DYNAMIC)
  692.       idl_rpc_delvar(dest);
  693.    dest->flags=0;
  694. /* 
  695.  * Switch on the variable type and do the store.
  696.  */
  697.    switch(dest->type = type){
  698.    case IDL_TYP_BYTE: 
  699.       dest->value.c = value->c;
  700.       break;
  701.    case IDL_TYP_INT:
  702.       dest->value.i = value->i;
  703.       break;
  704.    case IDL_TYP_LONG:
  705.       dest->value.l = value->l;
  706.       break;
  707.    case IDL_TYP_FLOAT:
  708.       dest->value.f = value->f;
  709.       break;
  710.    case IDL_TYP_DOUBLE:
  711.       dest->value.d = value->d;
  712.       break;
  713.    case IDL_TYP_COMPLEX:
  714.       dest->value.cmp = value->cmp;
  715.       break;
  716.    case IDL_TYP_DCOMPLEX:
  717.       dest->value.dcmp = value->dcmp;
  718.       break;
  719.    case IDL_TYP_STRING:
  720.       dest->value.str = value->str;
  721.       IDL_RPCStrDup( &(dest->value.str), 1L);
  722.       dest->flags = IDL_V_DYNAMIC;    
  723.       break;
  724.    default:
  725.       fprintf(stderr,"IDL_RPCStoreScalar: Unknown Type");
  726.    }
  727.    return;  /* thats it, fairly simple */
  728. }
  729. /**************************************************************
  730.  * IDL_RPCMakeArray()
  731.  *
  732.  * Purpose:
  733.  *     This function is used to emulate the IDL function 
  734.  *     IDL_MakeTempArray() on the client side of the IDL RPC system.
  735.  *    This routine accepts parameters that describe the desired array,
  736.  *    and then creates a variable and allocates memory for the array.
  737.  *
  738.  *    The resulting array is marked such that all dynamic memory
  739.  *    will be deallocated by IDL_RPCDeltmp(), IDL_RPCVarCopy()..ect.
  740.  *
  741.  * entry:
  742.  *    type    - The IDL type code of the desired array.
  743.  *    n_dim    - The number of dimensions of the array.
  744.  *    dim    - An array that contains the size of each dimension.
  745.  *    init    - The type of initialization that is performed on the 
  746.  *          data block. If the value is set to IDL_BARR_INI_ZERO
  747.  *          the data block is cleared, otherwise no initialization
  748.  *          is done.
  749.  *    var    - A ^ to an IDL_VPTR. The address of the created variable
  750.  *          is placed in the location referenced by var.
  751.  *
  752.  * exit:
  753.  *    var     - referances the IDL_VPTR of the created variable.
  754.  *    Return Value:
  755.  *        On success the function returns the poniter to the array
  756.  *        data block. On failure, a NULL is returned.
  757.  *
  758.  */
  759. char * IDL_RPCMakeArray( int type, int n_dim, IDL_LONG dim[], 
  760.                 int init, IDL_VPTR *var)
  761. {
  762.    int      i;
  763.    char    *pData;
  764.    IDL_VPTR vTmp;
  765. /*
  766.  * Get a new IDL_VPTR
  767.  */
  768.    if( (vTmp = IDL_RPCGettmp()) == (IDL_VPTR)NULL)
  769.       return (char *)NULL;
  770. /*
  771.  * Alloc the array struct
  772.  */
  773.    vTmp->value.arr = (IDL_ARRAY*)calloc(1, sizeof(IDL_ARRAY));
  774.    if(!vTmp->value.arr){
  775.       IDL_RPCDeltmp(vTmp);
  776.       perror("calloc");
  777.       return((char*)NULL);
  778.    }
  779. /*
  780.  * Set up the vptr flags.
  781.  */
  782.    vTmp->flags |= IDL_V_ARR | IDL_V_DYNAMIC;
  783.    vTmp->type  = type;
  784.  
  785. /*
  786.  * Get the element size. Depends on the type. 
  787.  */
  788.    switch(type){
  789.    case IDL_TYP_BYTE:      
  790.      vTmp->value.arr->elt_len = sizeof(UCHAR);
  791.      break;
  792.    case IDL_TYP_INT:
  793.      vTmp->value.arr->elt_len = sizeof(short);
  794.      break;
  795.    case IDL_TYP_LONG:
  796.      vTmp->value.arr->elt_len = sizeof(IDL_LONG);
  797.      break;
  798.    case IDL_TYP_FLOAT:
  799.      vTmp->value.arr->elt_len = sizeof(float);
  800.      break;
  801.    case IDL_TYP_DOUBLE:
  802.      vTmp->value.arr->elt_len = sizeof(double);
  803.      break;
  804.    case IDL_TYP_COMPLEX:
  805.      vTmp->value.arr->elt_len = sizeof(IDL_COMPLEX);
  806.      break;
  807.    case IDL_TYP_DCOMPLEX:
  808.      vTmp->value.arr->elt_len = sizeof(IDL_DCOMPLEX);
  809.      break;
  810.    case IDL_TYP_STRING:
  811.      vTmp->value.arr->elt_len = sizeof(IDL_STRING);
  812.      break;
  813.    default:
  814.      break;
  815.    }
  816. /*
  817.  * Set the rest of the array fields, start with the number of 
  818.  * elements.
  819.  */
  820.    vTmp->value.arr->n_elts = 1;
  821.    for(i=0;i < n_dim; i++){
  822.      vTmp->value.arr->n_elts *= dim[i];
  823.      vTmp->value.arr->dim[i] = dim[i];
  824.    }
  825.    vTmp->value.arr->arr_len = vTmp->value.arr->elt_len *
  826.                   vTmp->value.arr->n_elts;
  827.    vTmp->value.arr->n_dim = n_dim;
  828.  /*
  829.  * Now allocate space for the data
  830.  */
  831.    pData = (char*)malloc(vTmp->value.arr->arr_len);
  832.    if(!pData){
  833.       perror("malloc");
  834.       IDL_RPCDeltmp(vTmp);
  835.       return((char*)NULL);
  836.    }
  837. /*
  838.  * Does the user want to initialize this to zero?
  839.  */
  840.    if(init == IDL_BARR_INI_ZERO)
  841.       bzero(pData, vTmp->value.arr->arr_len);
  842.             
  843.    vTmp->value.arr->data = (UCHAR*)pData;
  844.    *var = vTmp;            /* assign vptr to output */
  845.    
  846.    return pData;
  847. }
  848. /***************************************************************************
  849.  *IDL_RPCImportArray()
  850.  *
  851.  * Purpose:
  852.  *      This function is used to emulate the IDL function IDL_ImportArray()
  853.  *    on the client side of the IDL RPC system. This routine accepts 
  854.  *    a pointer to a data block that the user whishes to import into an
  855.  *    IDL variable as well as parameters that describe the attributes of 
  856.  *    the data. In addition to this information, the function accepts a
  857.  *    a pointer to a user supplied function that can be used to free 
  858.  *    the memory associated with the imported data.
  859.  *
  860.  *    The resulting array is marked such that all dynamic memory
  861.  *    will be deallocated by IDL_RPCDeltmp(), IDL_RPCVarCopy()..ect. as 
  862.  *     well as calling a user supplied memory deallocation call back function.
  863.  *
  864.  *     Note: This function does not support structure def. pointers as
  865.  *          does IDL_ImportArray(). Structures are not supported by the
  866.  *          RPC system. 
  867.  *  entry:
  868.  *    n_dim    - The number of dimesions in the array.
  869.  *    dim    - The number of elements of each dimension.
  870.  *    type    - The type of the array.
  871.  *    data    - Pointer to the array block that is being imported.
  872.  *    free_cb - Pointer to a function that should be called 
  873.  *              when freeing the data. If left null free() will be 
  874.  *          called.
  875.  *
  876.  *  exit:
  877.  *    Return Value:
  878.  *        On success, the function returns an IDL_VPTR that 
  879.  *        references the IDL_VARIABLE the contains the imported
  880.  *        array. On failure, NULL is returned.
  881.  */
  882. IDL_VPTR IDL_RPCImportArray(int n_dim, IDL_LONG dim[], int type, 
  883.                 UCHAR *data, IDL_ARRAY_FREE_CB free_cb)
  884. {
  885.    IDL_VPTR   pVptr;        /* vptr */
  886.    long       n_elements=1;
  887.    long       szElement;
  888.    int        i;
  889.  
  890. /*
  891.  * Are there any dimensions?
  892.  */
  893.    if(n_dim  <= 0){
  894.       fprintf(stderr, "IDL_RPCImportArray: Invalid Number of dimensions");
  895.       return (IDL_VPTR)NULL;
  896.    }
  897. /*
  898.  * What is the size of an element?
  899.  */
  900.    switch(type){
  901.    case IDL_TYP_INT:        szElement=sizeof(short); break;
  902.    case IDL_TYP_LONG:       szElement=sizeof(IDL_LONG); break;
  903.    case IDL_TYP_FLOAT:      szElement=sizeof(float); break;
  904.    case IDL_TYP_DOUBLE:     szElement=sizeof(double); break;
  905.    case IDL_TYP_COMPLEX:    szElement=sizeof(IDL_COMPLEX); break;
  906.    case IDL_TYP_DCOMPLEX:   szElement=sizeof(IDL_DCOMPLEX); break;
  907.    case IDL_TYP_STRING:     szElement=sizeof(IDL_STRING); break;
  908.    default:
  909.       fprintf(stderr, "IDL_RPCImportArray: Unknown Type\n");
  910.       return (IDL_VPTR)NULL;
  911.    }
  912. /*
  913.  * Get a temporary Variable
  914.  */ 
  915.    pVptr = IDL_RPCGettmp();
  916. /*
  917.  * Alloc an array block
  918.  */
  919.    pVptr->value.arr = (IDL_ARRAY*)calloc(1, sizeof(IDL_ARRAY));
  920.    if(!pVptr->value.arr){
  921.       IDL_RPCDeltmp(pVptr);
  922.       return (IDL_VPTR)NULL;
  923.    }
  924. /*
  925.  * Set-up the correct flags for the variable.
  926.  */
  927.    pVptr->flags |= IDL_V_ARR | IDL_V_DYNAMIC;
  928.    pVptr->type  = type;
  929.  
  930.    for(i=0; i<n_dim; i++){
  931.       pVptr->value.arr->dim[i] = dim[i];
  932.       n_elements *= dim[i];
  933.    }
  934.    pVptr->value.arr->elt_len = szElement;
  935.    pVptr->value.arr->n_dim = (UCHAR)n_dim;
  936.    pVptr->value.arr->arr_len = szElement*n_elements;
  937.    pVptr->value.arr->n_elts = n_elements;
  938.    pVptr->value.arr->free_cb = free_cb;
  939.    pVptr->value.arr->data = data;
  940. /*
  941.  * That's all
  942.  */
  943.    return pVptr;
  944. }
  945. /***************************************************************************
  946.  * idl_rpc_delvar
  947.  *
  948.  * Purpose:
  949.  *     This routine is used to free all of the dynamic memory associated
  950.  *     with a variable. This routine doesnt free the variable. This routine
  951.  *     should not be called by the user, but is used internally by the rpc
  952.  *     client side functions
  953.  * entry:
  954.  *    pVar    - A IDL_VPTR to the variable to have dynamic memory freed.
  955.  *
  956.  * exit:
  957.  *    pVar    - All dynamic memory associated with the variable( array 
  958.  *          and/or strings) is deallocated or a user call-back has been
  959.  *          called.
  960.  */
  961. void idl_rpc_delvar(IDL_VPTR pVar)
  962. {   
  963.    int i;
  964.    IDL_STRING *pStr;
  965.    int flags=0;
  966.  
  967.    flags = (IDL_V_TEMP & pVar->flags);
  968. /* 
  969.  * Check for an array.
  970.  */
  971.    if(pVar->flags & IDL_V_ARR){
  972.       if(pVar->flags & IDL_V_DYNAMIC){
  973.       /* 
  974.        * was a Free callback function declared?
  975.        */
  976.          if(pVar->value.arr->free_cb != (IDL_ARRAY_FREE_CB)NULL){
  977.         pVar->value.arr->free_cb((UCHAR*)pVar->value.arr->data);
  978.          }else{
  979.          /*
  980.           * Have a dynamic array that needs to be free'd. Is this a string 
  981.           * array?
  982.           */
  983.             if(pVar->type == IDL_TYP_STRING){
  984.            IDL_RPCStrDelete((IDL_STRING*)pVar->value.arr->data, 
  985.                 pVar->value.arr->n_elts);
  986.         }
  987.         free(pVar->value.arr->data);
  988.          }
  989.        }
  990.        free(pVar->value.arr); /* the array block is always dynamic */
  991.     }else if(pVar->type == IDL_TYP_STRING){
  992.        if(pVar->value.str.stype)
  993.       free(pVar->value.str.s);
  994.     }
  995. /*
  996.  *  Now just clear out the variable.
  997.  */
  998.     bzero((char*)pVar, sizeof(IDL_VARIABLE));
  999.     pVar->flags = flags; /* save temp flag. it is used to indicate  */
  1000.              /* that the variable struct is dynamic */
  1001. }
  1002. /****************
  1003.  * String Section.
  1004.  ***********************************************************************
  1005.  * idl_rpc_strup()
  1006.  *
  1007.  * Purpose:
  1008.  *     Used to upcase a string.
  1009.  *
  1010.  * entry:
  1011.  *    dst    - The destination of the string variable.
  1012.  *    src    - The source string
  1013.  *
  1014.  * exit: 
  1015.  *    dst contains a upcased version of src.
  1016.  *
  1017.  */
  1018. void idl_rpc_strup(char * dst, char * src)
  1019. {
  1020.   char c;
  1021.   do{
  1022.     c = *src++;
  1023.     if(islower(c)) 
  1024.        c = toupper(c);
  1025.   }while(*dst++ = c);
  1026. }
  1027. /****************************************************************************
  1028.  * IDL_RPCStrDup()
  1029.  *
  1030.  * Purpose:
  1031.  *    
  1032.  *     This function is used to emulate the Callable IDL function 
  1033.  *     IDL_RPCStrDup(). This function should only be used on the client
  1034.  *     side of the RPC routines.
  1035.  *
  1036.  * entry:
  1037.  *        str     - A ^ to an IDL_STRING struct array.
  1038.  *    n    - The number of elements in the str.
  1039.  *
  1040.  * exit:
  1041.  *    str contains copies of the string values that where contained
  1042.  *    in the IDL_STRING structures.
  1043.  *    If an error is detected, the string struct is cleared.
  1044.  */
  1045. void IDL_RPCStrDup(IDL_STRING *str, IDL_LONG n)
  1046. {
  1047.    for(;n--; str++){
  1048.      if(str->slen && str->stype){ 
  1049.         if((str->s = (char*)strdup(str->s))==(char*)NULL)
  1050.        bzero( (char*)str, sizeof(IDL_STRING));
  1051.        else 
  1052.         str->stype = 1;    /* flag for dynamic */
  1053.      }
  1054.    }
  1055. }
  1056. /***************************************************************************
  1057.  * IDL_RPCStrDelete()
  1058.  *
  1059.  * Purpose:
  1060.  *     This routine is used to free any dynamic memory contained in the 
  1061.  *     string descriptors.
  1062.  *
  1063.  * entry:
  1064.  *    str    - A ^ to an IDL_STRING struct array.
  1065.  *    n    - The number of elements in str.
  1066.  *
  1067.  * exit:
  1068.  *    All dynamic values in the strings are deallocated and the 
  1069.  *    IDL_STRING structs are set to reflect this.
  1070.  *
  1071.  */
  1072. void IDL_RPCStrDelete(IDL_STRING *str, IDL_LONG n)
  1073. {
  1074.    for(;n--; str++){
  1075.    /*
  1076.     * Free the string if it is dynamic and has a length
  1077.     */
  1078.       if(str->slen && str->stype){
  1079.      free(str->s);
  1080.      bzero((char*)str, sizeof(IDL_STRING));
  1081.       }
  1082.    }
  1083. }
  1084. /***************************************************************************
  1085.  * IDL_RPCStrStore()
  1086.  *
  1087.  * Purpose:
  1088.  *     This routine is used to store a C string into an IDL String. The
  1089.  *     C string is strdup'd.
  1090.  * 
  1091.  * entry:
  1092.  *    s    - The ^ to a IDL_STRING struct that will get copy of the 
  1093.  *          C string.
  1094.  *    fs    - The C string to copy.
  1095.  * exit:
  1096.  *    s contains a copy of the C string or has been cleared if fs = null.
  1097.  */
  1098. void IDL_RPCStrStore( IDL_STRING *s, char *fs)
  1099. {
  1100.   int   len;
  1101.  
  1102.   if((len=strlen(fs))){
  1103.      s->s = (char*)strdup(fs);
  1104.      s->slen = len;
  1105.      s->stype=1;
  1106.   } else 
  1107.      bzero((char*)s, sizeof(IDL_STRING));
  1108. }
  1109. /***************************************************************************
  1110.  * IDL_RPCStrEnsureLength()
  1111.  *
  1112.  * Purpose:
  1113.  *     Used to ensure that a string is of a certain length.
  1114.  *
  1115.  * entry:
  1116.  *    s    - A ^ to a IDL_STRING struct that will get the string.
  1117.  *    n    - The lenght to be allocated.
  1118.  *
  1119.  * exit:
  1120.  *    The string field of the IDL_STRING struct is set to the desired length.
  1121.  */
  1122. void IDL_RPCStrEnsureLength(IDL_STRING *s, int n)
  1123. {
  1124.   if(n){            /* make a non-null dynamic string */
  1125.     if( ((int)s->slen < n) || !(s->stype)){
  1126.        IDL_RPCStrDelete(s, 1L);
  1127.        s->s = (char*)malloc((unsigned)sizeof(char)*n+1);
  1128.        if(!s->s){
  1129.       bzero((char*)s, sizeof(IDL_STRING));
  1130.       return;
  1131.        }
  1132.        s->stype=1;
  1133.     }
  1134.     s->slen = n;
  1135.   }else {            /* Want a null string */
  1136.     if(s->slen){        
  1137.        IDL_RPCStrDelete(s, 1L);
  1138.        bzero((char*)s, sizeof(IDL_STRING));
  1139.     }
  1140.   }
  1141. }
  1142. /***************************************************************************
  1143.  */
  1144. void IDL_RPCVarGetData(IDL_VPTR v, IDL_LONG *n, char **pd,
  1145.             int ensure_simple)
  1146. /*
  1147.  * Given a pointer to a varible, return the number of elements
  1148.  * and a pointer to the data area. This routine takes care of the
  1149.  * distinction between arrays and scalars.
  1150.  *
  1151.  * entry:
  1152.  *    v - Variable for which data is desired.
  1153.  *    n - Address of variable to receive # of elements.
  1154.  *    pd - Address of variable to receive pointer to data.
  1155.  *    ensure_simple - If TRUE, this routine calls the ENSURE_SIMPLE
  1156.  *        macro on the argument v to screen out variables of the
  1157.  *        types it prevents. Otherwise, EXCLUDE_FILE is called,
  1158.  *        because file variables have no data area to return.
  1159.  *
  1160.  * exit:
  1161.  *    *n - Receives count of elements.
  1162.  *    *pd - Receives pointer to data.
  1163.  */
  1164. {
  1165.  
  1166.   if(!v->type)
  1167.     return;
  1168.   if (ensure_simple) {
  1169.     if((v->flags &(IDL_V_FILE|IDL_V_STRUCT))||
  1170.        (v->type & (IDL_TYP_OBJREF|IDL_TYP_PTR)))
  1171.         return;
  1172.   } else {
  1173.     if(v->flags & IDL_V_FILE)
  1174.        return;
  1175.   }
  1176.   if (v->flags & IDL_V_ARR) {    /* Array? */
  1177.     *n = v->value.arr->n_elts;   /* Return values */
  1178.     *pd = (char *) v->value.arr->data;
  1179.   } else {
  1180.     *n = 1;            /* Scalar, one element */
  1181.     *pd = (char *) &v->value;
  1182.   }
  1183. }
  1184.  
  1185.  
  1186.  
  1187.